/*
    - `Promise` 是一个类，在执行的时候，需要传递执行器进去，执行器会执行
    - `Promise` 有三种状态，成功`fulfilled`,失败`rejected`,等待`pending`
        状态变化，只能从 `pending` --> `fulfilled` 或 `pending` --> `rejected`
    - `resolve` 和 `reject` 是来改变状态的，
        resolve --> fulfilled
        reject --> rejected
    - `then`方法要做的是判断状态，如果状态是成功，就调用成功的回调函数，如果失败，就调用失败的回调函数；`then`方法是被定义在原型对象中的；
    - then成功回调函数有个值 表示成功的值，then失败回调函数有个值 表示失败的原因；
*/

const MyPromise = require('./024-MyPromise')
let promise = new MyPromise((resolve, reject) => { // Promise 改成 MyPromise
    console.log('1111')
    // resolve('成功');
    setTimeout(() => {
        reject('失败');
    }, 2000);
})
promise.then(value => { // 成功的回调函数
    console.log('1' + value)
}, reason => { // 失败的回调函数
    console.log('1' + reason)
})

promise.then(value => { // 成功的回调函数
    console.log('2' + value)
}, reason => { // 失败的回调函数
    console.log('2' + reason)
})
// 测试链式调用 传入参数是promise对象
function objPromise() {
    return new MyPromise((resolve, reject) => {
        resolve('objPromise')
    })
}
promise.then(value => {
    console.log(value)
    return objPromise()
}).then(value => {
    console.log(value)
})

// 5.测试自己返回自己，循环调用的情况
let p1 = promise.then(function (value) {
    return p1
}, function (reason) {

});
p1.then(function (value) {
    console.log(value)
}, function (reason) {
    console.log(reason)
});

// 6.测试捕捉错误
let promise1 = new MyPromise((resolve, reject) => { // Promise 改成 MyPromise
    console.log('2222')
    throw TypeError('constructor error')
    // resolve('成功');
    setTimeout(() => {
        reject('失败');
    }, 2000);
})
// 7. 测试 try...catch...抛错
promise1.then(value => { // 成功的回调函数
    console.log('promise1 ' + value)
    throw TypeError('then error')
}, reason => { // 失败的回调函数
    console.log('promise1 ' + reason)
    
}).then(value => {
    console.log('promise1 ' + '2 ' + value)
}, reason => {
    console.log('promise1 ' + '2 ' + reason)
})
// 8. 测试 Promise.all 方法
let p2 = new MyPromise((resolve, reject) => {
    setTimeout(()=>{
        resolve('p2-Promise')
    },200)
})
MyPromise.all(['a','b',p1(),p2(),'c']).then(result => console.log(result))
// 9. 测试 Promise.resolve
MyPromise.resolve(100).then(value=>{
    console.log(value)
})
MyPromise.resolve(p2()).then(value=>{
    console.log(value)
})
// 10. 测试 finally 方法
let p3 = new MyPromise((resolve,reject)=>{
    reject('p3 reject')
})
p3.finally(result=>{
     console.log(result)
 }).then(value=>{
     console.log(value)
 },reason=>{
    console.log(reason)
 })

 // 11. 测试 catch 方法
p3.then(value=>console.log(value))
  .catch(reason=>console.log(reason))
